Programando IA com R

Portfólio

Carregando pacotes

#install.packages('ggplot2', dependencies=TRUE, repos='http://cran.r-project.org')
#
#install.packages("lubridate")
#
#install.packages('plotly')
#
#install.packages('dplyr')
#
#install.packages('leaflet')
#
#install.packages('corrplot')
#install.packages('readxl')

library(ggplot2)
library(leaflet)
library(dplyr)
library(plotly)
library(lubridate)
library(corrplot)
library(readxl)

Conceitos de variáveis

Vetor

Toda variável no R é um vetor, um vetor pode visto como um conjunto de valores linear e homogêneo.

Para atribuir um valor à uma variável, utilizamos a seta <- indicando para onde estamos direcionando o valor.

É importante saber também, que para criar um vetor com valores, podemos utilizar a função c() que combina os valores em um vetor

Sendo assim, abaixo estamos criando a variável vetor e atribuindo o valor 1 5 4

vetor <- c(1, 5, 4)
vetor

[1] 1 5 4

Tipos de valores

Numéricos e Caracteres

No R tempos o conceito de tipos, onde cada valor tem um tipo específico, lembra das aulas de matemática sobre inteiros, decimais, etc?

Para verificar o tipo interpretado pelo R de um valor, podemos utilizar a função class(valor), onde valor é igual ao valor que você quer verificar.

class(5)

[1] "numeric"

class("Olá mundo")

[1] "character"

Reconhecendo tipos de variáveis

Veja que o R reconheceu o valor 5 como númerico e o texto “Olá mundo” como um conjunto de caracteres.

Isto também se aplica a variáveis, veja só:

variavel_numerica <- c(1,5,4,7)
variavel_caracteres <- c("Olá mundo")
class(variavel_numerica)

[1] "numeric"

class(variavel_caracteres)

[1] "character"

Também podemos usar as funções disponíveis em “is” para verificar os tipos, essa verificação retorna um tipo lógico para nós

variavel <- "5"
is.numeric(variavel)

[1] FALSE

is.character(variavel)

[1] TRUE

Lógicos

No R, também é possível criar tipos lógicos (verdadeiro ou falso)

logicos <- c(TRUE, FALSE, TRUE)
logicos2 <- c(T, F, T)
logicos

[1]  TRUE FALSE  TRUE

logicos2

[1]  TRUE FALSE  TRUE

class(logicos)

[1] "logical"

Veja que é possível abreviar as declarações.

Inteiros Explicitos

Você deve ter percebido que no caso do tipo numérico, o tipo não foi declarado explicitamente como inteiro, para fazer isso veja o próximo trecho:

inteiros <- c(1L, 2L, 3L)
inteiros

[1] 1 2 3

class(inteiros)

[1] "integer"

Gerando sequências

Gerar sequências no R é uma coisa muito fácil e divertida! Temos algumas formas para fazer isso:

#Gerando números de 1 a 10
1:10

 [1]  1  2  3  4  5  6  7  8  9 10

#Gerando números de 10 a 1
10:1

 [1] 10  9  8  7  6  5  4  3  2  1

#Gerando números de 100 a 120
seq(100, 120)

 [1] 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

#Gerando 10 números a partir de 100
seq(100, length.out = 10)

 [1] 100 101 102 103 104 105 106 107 108 109

#Gerando números de 10 a 20 de 2 em 2
seq.int(from = 10, to = 20, by = 2)

[1] 10 12 14 16 18 20

#Gerando 20 números
seq_len(20)

 [1]  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20

#Gerando um vetor do mesmo tamanho que o vetor passado
seq_along(c(70, 2))

[1] 1 2

#Repetindo o número 4 5 vezes
rep(4, times = 5)

[1] 4 4 4 4 4

NA, NaN, Inf, -Inf e NULL

Os tipos especiais são valores que possuem uma característica bem específica.

NA = Não disponível (Not Available) NaN = Não númerico (Not A Number) Inf = Infinito -Inf = -Infinito NULL = Vazio

Perceba que NA possui um tipo, mas NULL não, NULL representa o nada no caso do R e de diversas linguagens de programação.

Um detalhe é que não é possível colocar NULL em um vetor, ou seja, caso criemos um vetor com NULL, o R remove ele automáticamente

valor.na <- NA
valor.null <- NULL
valor.infinito <- Inf;
valor.menos.infinito <- -Inf
valor.nan <- NaN
vetor.com.null <- c(10,10,10,NULL)
vetor.com.null

[1] 10 10 10

Operações aritméticas

No R é possível fazer operações aritméticas entre os valores disponíveis, abaixo teremos exemplos para algumas operações aritméticas simples:

# Adição
adicao <- 5+5
adicao

[1] 10

# Subtração
subtracao <- 5-5
subtracao

[1] 0

# Multiplicação
multiplicao <- 5*5
multiplicao

[1] 25

# Divisão
divisao <- 5/5
divisao

[1] 1

#Raiz Quadrada
raiz <- sqrt(10)
raiz

[1] 3.162278

#Numero imaginário
numero <- 1i
numero

[1] 0+1i

Operações com vetores

As operações aritméticas se estendem a vetores também, veja abaixo um exemplo:

# Vetor de dez posições
vetor <- c(1:10)
vetor * 2

 [1]  2  4  6  8 10 12 14 16 18 20

# Veja que obtemos o dobro de cada valor do vetor, isso se aplica para todas as operações.

Tipos avançados

Fatores

Através de fatores, é possível classificar dados para que as máquinas consigam processar com mais facilidade. Veja que no output, o R escreve “Levels: Feminino Masculino” para identificar as classes encontradas.

sexo <- c("Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino","Feminino", "Masculino")
fatorado <- as.factor(sexo);
fatorado

 [1] Feminino  Masculino Feminino  Masculino Feminino  Masculino Feminino  Masculino Feminino  Masculino
Levels: Feminino Masculino

Listas

No R, temos o tipo de lista onde é possível armazenar vetores com tipos diferentes:

v1 <- c(1, 2, 3);
v2 <- c(T, F, T);
v3 <- c("a", "b", "c");
lista <- list(v1, v2, v3)
class(lista)

[1] "list"

lista

[[1]]
[1] 1 2 3

[[2]]
[1]  TRUE FALSE  TRUE

[[3]]
[1] "a" "b" "c"

Matrizes

Matrizes são um conjunto de valores distribuídos em linhas e colunas. A visualização abaixo deve esclarecer melhor:

matriz <- matrix(ncol = 5, nrow = 5, data = 1:5)
matriz

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    1    1    1    1
[2,]    2    2    2    2    2
[3,]    3    3    3    3    3
[4,]    4    4    4    4    4
[5,]    5    5    5    5    5

Você deve ter percebido que também é possível atribuir uma matriz para uma variável com esse exemplo.

Vamos a um exemplo de operação com matrizes

matrizA <- matrix(ncol = 5, nrow = 5, data = 1:5)
matrizB <- matrix(ncol = 5, nrow = 5, data = 1:5)
# Esta operação abaixo não é uma multiplicação de matrizes, é apenas uma multiplicação de valores.
matriz <- matrizA * matrizB
matriz

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    1    1    1    1
[2,]    4    4    4    4    4
[3,]    9    9    9    9    9
[4,]   16   16   16   16   16
[5,]   25   25   25   25   25

Para fazermos uma multiplicaçáo de matrizes, precisamos seguir uma regra: a quantidade de colunas da matriz A deve ser equivalente a quantidade de linhas da matriz B.

Abaixo um exemplo de multiplicação de matrizes:

linhas <- 5
colunas <- 10
matrizA <- matrix(ncol = linhas, nrow = colunas, data = 1:2)
matrizB <- matrix(ncol = colunas, nrow = linhas, data = 1:2)
matrizA %*% matrizB

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]    7    8    7    8    7    8    7    8    7     8
 [2,]   14   16   14   16   14   16   14   16   14    16
 [3,]    7    8    7    8    7    8    7    8    7     8
 [4,]   14   16   14   16   14   16   14   16   14    16
 [5,]    7    8    7    8    7    8    7    8    7     8
 [6,]   14   16   14   16   14   16   14   16   14    16
 [7,]    7    8    7    8    7    8    7    8    7     8
 [8,]   14   16   14   16   14   16   14   16   14    16
 [9,]    7    8    7    8    7    8    7    8    7     8
[10,]   14   16   14   16   14   16   14   16   14    16

Funções úteis para matrizes

matrizA <- matrix(ncol = 2, nrow = 2, data = 1:4)
print("Dimensões da matriz - Linhas x Colunas")

[1] "Dimensões da matriz - Linhas x Colunas"

dim(matrizA)  #inversa, esta deve ser quadrada

[1] 2 2

print("Transposta")

[1] "Transposta"

t(matrizA) #transposta

     [,1] [,2]
[1,]    1    2
[2,]    3    4

print("Identidade")

[1] "Identidade"

diag(matrizA) #identidade

[1] 1 4

print("Inversa")

[1] "Inversa"

solve(matrizA)  #inversa, esta deve ser quadrada

     [,1] [,2]
[1,]   -2  1.5
[2,]    1 -0.5

matrizA <- cbind(matrizA, c(5,2)) #Adiciona colunas no fim da matriz
#Colunas adicionadas
print("Colunas adicionadas")

[1] "Colunas adicionadas"

matrizA

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    2

print("Linhas adicionadas")

[1] "Linhas adicionadas"

matrizA <- rbind(matrizA, c(5,2, 3))
matrizA

     [,1] [,2] [,3]
[1,]    1    3    5
[2,]    2    4    2
[3,]    5    2    3

Data Frame

Criar um dataframe é bem simples, veja:

vetorA <- c(1,5,4,7)
vetorB <- c("Olá mundo")
dataframe <- data.frame(vetorA, vetorB)
# Colocando nomes nas colunas
colnames(dataframe) <- c("Numérico", "Texto")
dataframe

O mais legal do dataframe, é que conseguimos colocar dados heterogêneos, ao contrário dos vetores e matrizes.

Também é possível criar um dataframe a partir de uma lista:

lista <- list(c(1,2), c(T,F), c("teste", "teste2"))
dataframe <- data.frame(lista)
dataframe

Datas

Geralmente o trabalho com datas é uma das coisas mais complexas em programação. Vamos ver aqui algumas funções que o R disponibiliza para nós:

data.texto = "13/11/2018 T 19:10:00"
data.date = as.Date(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time1 = as.POSIXct(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time2 = as.POSIXlt(data.texto,format="%d/%m/%Y T %H:%M:%S",tz="America/Sao_Paulo")
data.time1

[1] "2018-11-13 19:10:00 -02"

data.time2

[1] "2018-11-13 19:10:00 -02"

data.date 

[1] "2018-11-13"

Através do método unclass, podemos ver o conteúdo real de uma variável, suas propriedades e etc. Quando passamos data.date para a função unclass, obtemos a quantidade de dias desde 01/01/1970 até a data da variável.

unclass(data.date)

[1] 17848

No caso de time1 e time2 veja que não temos diferenças no texto, entretanto veja quando fazemos o unclass.

print("Time1")

[1] "Time1"

unclass(data.time1)

[1] 1542143400
attr(,"tzone")
[1] "America/Sao_Paulo"

print("Time2")

[1] "Time2"

unclass(data.time2)

$`sec`
[1] 0

$min
[1] 10

$hour
[1] 19

$mday
[1] 13

$mon
[1] 10

$year
[1] 118

$wday
[1] 2

$yday
[1] 316

$isdst
[1] 1

$zone
[1] "-02"

$gmtoff
[1] NA

attr(,"tzone")
[1] "America/Sao_Paulo"

O unclass no time1 retorna a contagem em segundos desde 01/01/1970 até a data da variável!!

Para obter a data atual

Sys.Date()

[1] "2018-12-19"

Lubridate

Lubridate é um pacote disponibilizado para manipular datas no R. Para instalar e carregar:

#install.packages("lubridate")
#library(lubridate)

O lubridate fornece funções que retornarão a data no formato solicitado e além disso ele trabalha com o conceito de duração.

segundos  = dseconds(260)
minutos  = dminutes(260)
anos  = dyears(260)
duration(10, units = "seconds")

[1] "10s"

segundos

[1] "260s (~4.33 minutes)"

minutos

[1] "15600s (~4.33 hours)"

anos

[1] "8199360000s (~259.82 years)"

#abaixo as funções de data
#Ano mes dia
data <- ymd("20190101")
# Dia mes ano hora
dmy_h("1110201810")

[1] "2018-10-11 10:00:00 UTC"

# Retorna o dia da semana
wday(data, label = T)

[1] Tue
Levels: Sun < Mon < Tue < Wed < Thu < Fri < Sat

Estruturas de controle

Para tomar algumas decisões durante a execução de código, o R fornece algumas estruturas de controle.

souBonito <- TRUE
if (souBonito) {
  print("Eu Sei")
} else {
  print("Vish")
}

[1] "Eu Sei"

souBonito <- F
ifelse(souBonito, "verdade", "falso")

[1] "falso"

Estruturas de controle são muito úteis quando você precisa testar algum tipo de condição, se alguma compra foi realizada por exemplo, ou se algo ocorreu.

Estruturas de repetição = loops

Loops são utilizados quando precisamos por exemplo repetir um conjunto de instruções para determinados itens.

itens <- c(10,20,30)
for (variable in itens) {
  print(variable)
}

[1] 10
[1] 20
[1] 30

Veja que escrevemos todos os itens do vetor na tela, podemos utilizar para consolidar informações e enfim, para qualquer conjunto de instruções que precise se repetir.

Vamos montar um dataframe com um loop

vetor <- 1:10
acumulado <- 0
tabela <- data.frame();
for (variable in vetor) {
  acumulado <- variable + acumulado
   tabela <- rbind(tabela, c(variable, acumulado))
}
colnames(tabela) <- c("Valor1", "Acumulado")
tabela

Funções

Funções são utilizadas quando queremos reaproveitar algum trecho de código específico. por exemplo, digamos que precisamos calcular o enesimo termo de uma Progressão Aritmética

primeiro.termo <- 1
razao <- 2
obter.termo.pa <- function(primeiro.termo, numero.termo, razao) {
  return(primeiro.termo + (numero.termo - 1) * razao)
}
obter.termo.pa(primeiro.termo, 50, razao)

[1] 99

Em funções, podemos receber reticências como parametro, que significa que podemos receber N parametros na função. Um exemplo de função assim é a função paste.

concatena <- function(...) {
  c <- paste(...)
  c
}
concatena("Sergio", "Prates")

[1] "Sergio Prates"

Amostras

No R possuimos a função sample para randomizar a ocorrência de determinados valores

# Letras de a até g
amostra1 <- letters[1:7]
# Letras de A até D
amostra2 <- LETTERS[1:4]
# Pode repetir as ocorrências
sample(x = amostra1, size = 20, replace = T)

 [1] "c" "f" "e" "e" "g" "g" "b" "g" "d" "d" "c" "g" "a" "b" "e" "a" "f" "f" "b" "a"

# Não pode repetir as ocorrências
sample(x = amostra2, size = 3,  replace = F)

[1] "C" "B" "D"

Para garantir que sempre o mesmo resultado aconteça, podemos utilizar a função set.seed com um valor fixo

set.seed(1)
sample(x = amostra1, size = 20, replace = T)

 [1] "b" "c" "e" "g" "b" "g" "g" "e" "e" "a" "b" "b" "e" "c" "f" "d" "f" "g" "c" "f"

Simulações

O R nos fornece alguns comandos para gerar dados aleatórios, sendo eles da família normal, binomial e uniforme.

Os comandos da familia normal possuem norm no final, os binomiais possuem binom e assim por diante… Veja abaixo exemplos:

set.seed(18) #garantindo que sempre sairá o mesmo resultado
# sd representa o desvio padrão dos dados
rnorm(n=10, mean=0, sd=1)

 [1]  0.92645924  1.82282117 -1.61056690 -0.28510975 -0.34207303  0.36617615 -1.32704085  2.41259221  0.06381535  1.54551478

dnorm(x = 1:10, mean = 0, sd = 1)

 [1] 2.419707e-01 5.399097e-02 4.431848e-03 1.338302e-04 1.486720e-06 6.075883e-09 9.134720e-12 5.052271e-15 1.027977e-18 7.694599e-23

pnorm( q = 1:10, mean = 0, sd = 1)

 [1] 0.8413447 0.9772499 0.9986501 0.9999683 0.9999997 1.0000000 1.0000000 1.0000000 1.0000000 1.0000000

rbinom(size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1), n = 10)

 [1]  0  0  1  1  0  1  7  8  9 10

dbinom(size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1), x = 1:10)

 [1] 1e-01 1e-02 1e-03 1e-04 1e-05 1e-06 1e+00 1e+00 1e+00 1e+00

pbinom(q = 1:10, size = 1:10, prob = c(0.1,0.1,0.1,0.1,0.1,0.1,1,1,1,1))

 [1] 1 1 1 1 1 1 1 1 1 1

rpois(100, 5)

  [1]  5  5  3  4  8  5  3  3  3  6  8  5  6  5  2  2  7  1  3  5  3  3  6  6  1  4  3  7  5  5  4  2  1  3  3  6  5 12  6  7  8  4  2 10  7  4  6
 [48]  5  2  3  6  5  7  5  6  6 11  5  6  7  7  4  5  3  6  6  7  4  2  6  4  6  4  6  3  4  3  7  6 13  4  3  5  3  1  4  3  5  8  8  5  6  6  6
 [95]  3  6  5  3  2  1

Resumo do dataset com Glimpse

Glimpse é uma função que está dentro do pacote dplyr. É muito interessante por que conseguimos ver um resumo dos dados e amostras. Veja abaixo para ficar mais claro o glimpse com o dataset do mtcars

glimpse(mtcars)

Observations: 32
Variables: 11
$ mpg  <dbl> 21.0, 21.0, 22.8, 21.4, 18.7, 18.1, 14.3, 24.4, 22.8, 19.2, 17.8, 16.4, 17.3, 15.2, 10.4, 10.4, 14.7, 32.4, 30.4, 33.9, 21.5, 15...
$ cyl  <dbl> 6, 6, 4, 6, 8, 6, 8, 4, 4, 6, 6, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 8, 8, 8, 8, 4, 4, 4, 8, 6, 8, 4
$ disp <dbl> 160.0, 160.0, 108.0, 258.0, 360.0, 225.0, 360.0, 146.7, 140.8, 167.6, 167.6, 275.8, 275.8, 275.8, 472.0, 460.0, 440.0, 78.7, 75....
$ hp   <dbl> 110, 110, 93, 110, 175, 105, 245, 62, 95, 123, 123, 180, 180, 180, 205, 215, 230, 66, 52, 65, 97, 150, 150, 245, 175, 66, 91, 11...
$ drat <dbl> 3.90, 3.90, 3.85, 3.08, 3.15, 2.76, 3.21, 3.69, 3.92, 3.92, 3.92, 3.07, 3.07, 3.07, 2.93, 3.00, 3.23, 4.08, 4.93, 4.22, 3.70, 2....
$ wt   <dbl> 2.620, 2.875, 2.320, 3.215, 3.440, 3.460, 3.570, 3.190, 3.150, 3.440, 3.440, 4.070, 3.730, 3.780, 5.250, 5.424, 5.345, 2.200, 1....
$ qsec <dbl> 16.46, 17.02, 18.61, 19.44, 17.02, 20.22, 15.84, 20.00, 22.90, 18.30, 18.90, 17.40, 17.60, 18.00, 17.98, 17.82, 17.42, 19.47, 18...
$ vs   <dbl> 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1
$ am   <dbl> 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1
$ gear <dbl> 4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 4, 4, 4, 3, 3, 3, 3, 3, 4, 5, 5, 5, 5, 5, 4
$ carb <dbl> 4, 4, 1, 1, 2, 1, 4, 2, 2, 4, 4, 3, 3, 3, 4, 4, 4, 1, 2, 1, 1, 2, 2, 4, 2, 1, 2, 2, 4, 6, 8, 2

Plots básico

Para fazer plots, ou gráficos em R podemos utilizar a função plot()

plot(x = cars$speed, y = cars$dist, type = "p", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

plot(x = cars$speed, y = cars$dist, type = "l", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

#Histogramas servem para analisar frequências
plot(x = cars$speed, y = cars$dist, type = "h", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

plot(x = cars$speed, y = cars$dist, type = "b", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

plot(x = cars$speed, y = cars$dist, type = "o", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

plot(x = cars$speed, y = cars$dist, type = "s", xlab = "Velocidade", ylab = "Distância", main = "Distância x Velocidade")

#Analisar correlação
#Tendencia
#Distribuição
#Box plot é um summary em gráficos
boxplot(airquality)

boxplot(airquality$Ozone, outline = F)

Usando outra biblioteca…

Podemos utilizar a equação abaixo para plotar um gráfico linear \(y = \beta_0 + \beta_1 + \epsilon\)

Onde

\(\beta_0 = 0,5\)

\(\beta_1 = 2,0\)

\(x\sim N(0;1²)\)

\(\epsilon\sim N(0;2²)\)

#install.packages('plotly')
#library(plotly)
set.seed(5)
x = rnorm(n=350, mean=0, sd=1)
e = rnorm(n=350, mean=0, sd=2)
y=0.5 + 2*x + e
plot(x=x, y=y)

plot_ly(x=x, y=y, type="scatter", mode="markers")

Gerando gráfico com pontos e linhas

airquality %>% filter(Month == 5 & !is.na(Ozone)) %>% arrange(Ozone) %>% select(Ozonio = Ozone) -> ozonio
ozonio %>% summary() %>% as.list() -> valores
plot(ozonio$Ozonio)
minimo <- min(teste$Ozonio)
maximo <- max(teste$Ozonio)
media <- mean(teste$Ozonio)
mediana <- median(teste$Ozonio)
quartil <- quantile(teste$Ozonio)
lines(c(0, 30), c(minimo, minimo), col = 'blue')

lines(c(0, 30), c(maximo, maximo), col = 'blue')
lines(c(0, 30), c(media, media), col = 'blue')

lines(c(0, 30), c(mediana, mediana), col = 'red')
lines(c(0, 30), c(11.00, 11.00), col = 'blue')

Baixando dados externos

Com a função download file podemos baixar arquivos da web, neste caso ele sempre trata como texto os dados.

baixar <- function(url) {
  
  #Cria a pasta caso não exista
  
  if(!file.exists('data')){
    dir.create('data')
  }
  
  file.url = url
  file.local = file.path('./data', basename(file.url))
  download.file(url = file.url, destfile = file.local , mode='wb')
}
baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas.csv')

trying URL 'https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas.csv'
Content type 'text/plain; charset=utf-8' length 1412 bytes
downloaded 1412 bytes

baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Partidas.csv')

trying URL 'https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Partidas.csv'
Content type 'text/plain; charset=utf-8' length 239003 bytes (233 KB)
downloaded 233 KB

baixar('https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Jogadores.csv')

trying URL 'https://raw.githubusercontent.com/elthonf/fiap-mba-r/master/data/Copas-Jogadores.csv'
Content type 'text/plain; charset=utf-8' length 2150588 bytes (2.1 MB)
downloaded 2.1 MB

baixar('https://github.com/elthonf/fiap-mba-r/raw/master/data/cameras.baltimore.xlsx')

trying URL 'https://github.com/elthonf/fiap-mba-r/raw/master/data/cameras.baltimore.xlsx'
Content type 'application/octet-stream' length 15453 bytes (15 KB)
downloaded 15 KB

Lendo dados de csv’s

Para ler dados de csvs podemos utilizar a função read.csv

copas <- read.csv('./data/Copas.csv', header = T)
copas

Para ler dados do excel, podemos utilizar o pacote

df.cameras <- read_xlsx('./data/cameras.baltimore.xlsx')
head(df.cameras)

Manipulando estruturas de tabelas com dplyr

O pacote dplyr nos ajuda a manipular estruturas de tabelas de maneira bastante eficiente.

Abaixo utilizamos o pipe para passar o conteúdo

BrFlights2 <- read.csv('./data/BrFlights2.csv')

embedded nul(s) found in input

BrFlights2 %>%
mutate(Partida.Atraso = (Partida.Real - Partida.Prevista)) %>% 
mutate(Chegada.Atraso = (Chegada.Real - Chegada.Prevista)) %>% 
mutate(Distancia = (sqrt((LatOrig - LatDest)^2 + (LongOrig - LongDest)^2))) %>% 
mutate(TempoViagem.Real = (Chegada.Real - Partida.Real)) -> tabela

<U+393C><U+3E31>-<U+393C><U+3E32> not meaningful for factors<U+393C><U+3E31>-<U+393C><U+3E32> not meaningful for factors<U+393C><U+3E31>-<U+393C><U+3E32> not meaningful for factors

tabela

Visualizando gráficos lado a lado

#exibir duas linhas e duas colunas
par(mfrow=c(2,2))
boxplot(airquality$Ozone~airquality$Solar.R)
boxplot(airquality$Ozone~airquality$Wind)

hist(airquality$Ozone)
hist(airquality$Wind)

Clusterizando dados, identificando proximidades

set.seed(1909)
x <- rnorm(15, mean = rep(1:3, each = 5), sd = 0.2)
y <- rnorm(15, mean = rep(c(1,2), each = 5), 0.2)
plot(x, y, col = 'blue', pch = 8, cex = 1)
text(x + 0.05, y + 0.05, labels = as.character(1:15))

df <- data.frame(x, y)
nclusters <- 3
modelo <- kmeans(x = df, centers = nclusters, iter.max = 5)
plot(x,y,col= modelo$cluster, pch = 19, cex=2);
points(modelo$centers, col=1:nclusters, pch = 3, cex=3, lwd = 2)

Clusterizando 3 dimensões

set.seed(1909)
velocidade <- rnorm(15, mean = rep(1:3, each = 5), sd = 0.2)
vento <- rnorm(15, mean = rep(c(1,2), each = 5), 0.2)
altura <- rnorm(15, mean = rep(c(1,2), each = 5), 0.2)
df <- data.frame(velocidade, vento, altura)
nclusters <- 4
modelo <- kmeans(x = df, centers = nclusters, iter.max = 5)
plot(df,col= modelo$cluster, pch = 19, cex=2);
points(modelo$centers, col=1:nclusters, pch = 3, cex=3, lwd = 2)

Cluster com plotly

set.seed(1909)
x <- rnorm(15, mean = rep(1:3, each = 5), sd = 0.2)
y <- rnorm(15, mean = rep(c(1,2), each = 5), 0.2)
plot(x, y, col = 'blue', pch = 8, cex = 1)
text(x + 0.05, y + 0.05, labels = as.character(1:15))

df <- data.frame(x, y)
nclusters <- 3
modelo <- kmeans(x = df, centers = nclusters, iter.max = 5)
plot_ly(df,
        x = ~x, 
        y = ~y,
        type = 'scatter', mode ='markers',color = modelo$cluster)

Cluster 3D com plotly

set.seed(1909)
velocidade <- rnorm(15, mean = rep(1:50, each = 5), sd = 0.2)
vento <- rnorm(15, mean = rep(c(1,25), each = 5), 0.2)
altura <- rnorm(15, mean = rep(c(1,25), each = 5), 0.2)
df <- data.frame(velocidade, vento, altura)
nclusters <- 4
modelo <- kmeans(x = df, centers = nclusters, iter.max = 5)
plot_ly(df,
        x = ~velocidade, 
        y = ~vento,
        z= ~altura,
        type = 'scatter3d', mode ='markers',color = modelo$cluster)

Dendrograma (Clusterização hierárquica)

set.seed(1909)
x <- rnorm(15, mean = rep(1:3, each = 5), sd = 0.2)
y <- rnorm(15, mean = rep(c(1, 2), each = 5), sd = 0.2)
mydata <- data.frame(x, y)
# Distancia euclidiana
#dist(mydata[1:7,])
#Distancia de manhattan
#dist(mydata[1:7,], method = "manhattan")
modelo.hc <- hclust(dist(mydata))
plot(modelo.hc, main="Dendograma simples",xlab="Observações", sub="", ylab ="DIstancia")

Anaálise da média de ozonio diário por mês

p2 <- airquality %>% 
  mutate(mesFator = factor(Month)) %>% 
  
  filter(is.na(Ozone) == F) %>% 
  
  group_by(Day, mesFator) %>% 
  
  summarise(media=mean(Ozone)) %>% 
  ggplot(aes(Day, media, color = mesFator)) +
  geom_line(size = 1.5) +
  labs(x = "Mês", y = "Média de quantidade de ozônio")
p2

Gráfico de Violino

p <- ggplot(mtcars, aes(factor(cyl), mpg))
p + geom_violin(aes(fill = factor(am)))

Gráfico de pizza

ggplot(airquality,
  aes(x = factor(Month), fill = Wind) ) +
  geom_bar() +
  coord_polar(theta = "y") +
  scale_x_discrete("")

Gráfico de Barras

ggplot(airquality) +
  geom_bar(aes(Temp, fill=Temp))

Gráfico de barras verticais

ggplot(airquality, aes(Month, fill=Month) ) +
  geom_bar() + coord_flip()

Gráfico Densidade 2D

ggplot(airquality, aes( x=Wind, y=Temp) ) +
  geom_point( size=1 ) + geom_density2d()

Gráfico hexágonos

ggplot(airquality, aes(Wind, Temp)) +
  geom_hex( bins=30 )

Gráfico smooth, em cinza temos o grau de confiança na linha de tendencia.

ggplot(airquality, aes(Wind, Temp) ) +
  geom_point() + geom_smooth()

Mapa de calor

p3 <- airquality %>%
  group_by(Month, Day) %>%
  summarise(TemperaturaMedia = median(Temp)) %>%
  ggplot(aes(Day, Month, fill = TemperaturaMedia)) +
  geom_tile() +
  labs(x = "Dia do mês", y = "Mês") +
  scale_fill_distiller(palette = "Spectral")
p3

Mapa de correlação

airquality %>%
  cor(use="complete.obs", method = "spearman") %>%
  corrplot(type="lower", method="circle", diag=FALSE)